# 一、创建一个圆Circle类，
# 为该类提供一个初始化方法，用于初始化半径
# 为该类提供两个方法，
# 方法一用 于求圆的面积，方法二用于求圆的周长
import math
class Circle:
    def __init__(self,r):
        self.r=r

    def get_area(self):
        return math.pi*self.r*self.r

    def get_circum(self):
        return 2*math.pi*self.r

    def __str__(self):
        return f"圆的半径{self.r},面积{self.get_area()},周长{self.get_circum()}"

i=int(input("请输入圆的半径："))
circle=Circle(i)
print(f"圆的面积{circle.get_area()},圆的周长{circle.get_circum()}")


# 二、
# # 封装圆形类，
# # 包含数据，圆心(x,y)，半径(r)
# # 包含方法，面积与周长
# #
# #
# # 封装管理类，管理10个 半径位于10-30之间的圆  位置在【0，0， 100， 100】
# # 封装方法
# #     找到面积最大的圆
# #     找到距离最远的两个圆
import math
import random


class Circle:
    def __init__(self, x, y, r):
        self.r = r
        self.x = x
        self.y = y

    def get_area(self):
        return math.pi * self.r * self.r

    def get_circum(self):
        return 2 * math.pi * self.r

    def __str__(self):
        return (f"圆的半径{self.r},X={self.x},Y={self.y},"
                f"面积{self.get_area()},周长{self.get_circum()}")


class CircleManage:
    def __init__(self):
        self.circles = []

    def add_circle(self, c):
        self.circles.append(c)

    def get_max_circle(self):
        max_c = None
        max_c_area = 0
        for c in self.circles:
            if max_c is None:
                max_c = c
            else:
                if max_c_area < c.get_area():
                    max_c_area = c.get_area()
                    max_c = c
        return max_c

    def get_max_distance(self):
        max_dis = 0
        circles = []
        for i in range(len(self.circles) - 1):
            for j in range(i + 1, len(self.circles)):
                dis = math.sqrt(
                    (self.circles[i].y - self.circles[j].y) ** 2 + (self.circles[i].x - self.circles[j].x) ** 2)
                if max_dis < dis:
                    max_dis = dis
                    circles.clear()
                    circles.append(self.circles[i])
                    circles.append(self.circles[j])
        return circles

def mian():
    cm = CircleManage()
    for i in range(10):
        cir = Circle(x=random.randint(0, 100), y=random.randint(0, 100), r=random.randint(10, 30))
        print(f'X={cir.x},Y={cir.y},R={cir.r},Area={cir.get_area()}')
        cm.circles.append(cir)
    print(f"最大的圆:{cm.get_max_circle()}")
    # print(f"距离最远的圆：{cm.get_max_distance()}")
    for c in cm.get_max_distance():
        print(c)


mian()

# 三、创建Rectangle类，初始化属性width、height；
# 在Rectangle类中添加两个方法计算矩形的周长和面积；
# 在Rectangle类中添加方法输出矩形的周长和面积
# 生成10个矩形 width,height都位于 5-10之间  求周长与面积之和最大的一个矩形
import random
class Rectangle:
    def __init__(self,width,height):
        self.width=width
        self.height=height

    def get_circum(self):
        return 2*(self.width+self.height)
    def get_area(self):
        return self.width*self.height
    def __str__(self):
        return (f"矩形款{self.width},矩形长{self.height},"
                f"矩形周长{self.get_circum()},矩形面积{self.get_area()}")


# r1=Rectangle(4,6)
# print(r1.get_area(),r1.get_circum())
class RectangleMange:
    def __init__(self):
        self.rectangles=[]
    def add_sum(self,r):
        self.rectangles.append(r)
    def max_rectangle(self):
        max_r=None
        max_w=None
        max_h=None
        for i in range(len(self.rectangles)):
            if max_r==None:
                max_r=self.rectangles[i][0]+self.rectangles[i][1]
                max_w=self.rectangles[i][0]
                max_h=self.rectangles[i][1]
            elif max_r<self.rectangles[i][0]+self.rectangles[i][1]:
                max_r=self.rectangles[i][0]+self.rectangles[i][1]
                max_w = self.rectangles[i][0]
                max_h = self.rectangles[i][1]
        return f"和最大是{max_r},宽为{max_w},长为{max_h}"
def main():
    rm=RectangleMange()
    for i in range(10):
        r=Rectangle(width=random.randint(5,10),height=random.randint(5,10))
        r.get_area()
        r.get_circum()
        print(f"矩形款{r.width},矩形长{r.height},"
              f"矩形周长{r.get_circum()},矩形面积{r.get_area()}")
        d0=[r.get_area(),r.get_circum()]
        rm.add_sum(d0)
    #     print(r)
    print(rm.rectangles)
    print(rm.max_rectangle())
    # for r in rm.rectangle:
    #     print(r)
main()


# 四、使用面向对象封装一个栈（百度一个 栈 ：后进先出）
# 提供插入数据与删除数据的方法。
# 插入的数据放在最后，删除的数据就是最后一个插入的数据，提供方法返回栈中元素的个数
class Stack(object):
    def __init__(self,count):
        self.stacks=[]
        self.count=count

    def is_full(self):
        return len(self.stacks)==self.count

    def is_empty(self):
        return len(self.stacks)==0

    def add_e(self,e):
        if self.is_full():
            print("此栈已满，不能添加元素")
        else:
            self.stacks.append(e)

    def date_e(self):
        if self.is_empty():
            print("此栈已空，不能删除元素")
        else:
            e=self.stacks.pop()
            print(e)

s=Stack(3)
print(s.is_full(),s.is_empty())
s.add_e(10)
s.add_e(20)
print(s.is_full(),s.is_empty())
s.add_e(30)
s.add_e(40)
print(s.is_full(),s.is_empty())
s.date_e()
s.date_e()
print(s.is_full(),s.is_empty())
s.date_e()
s.date_e()
print(s.is_full(),s.is_empty())


# 六、编写汽车类（颜色，速度）
# 编写人类（名字，汽车实例）
# 编写列表 放入三个人， 遍历列表依次打印每个人的信息（包含汽车）
import random
class Car:
    def __init__(self, color, v):
        self.color = color
        self.v = v

    def __str__(self):
        return f"汽车颜色{self.color},汽车速度{self.v}"


class Person:
    def __init__(self, name, c):
        self.name = name
        self.c = c

    def __str__(self):
        return f"姓名：{self.name},汽车实例：{self.c}"


pl = []
rl=["red","blue","black"]

def main():
    for i in range(3):
        c=Car(rl[random.randint(0,2)],random.randint(40,120))
        print(c)
        p=Person(name=input("请输入名字"),c=c)
        pl.append(p)
    for c in pl:
        print(c)
main()